package com.yhq.basic.thread.juc.collection;

import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.concurrent.ConcurrentHashMap;

/**
 * jdk7
 *     HashMap底层
 *         Entry结构
 *          final k key; //允许为null
 *          V value;
 *          Entry<K,V> next;
 *          对于链表赋值，头插法
 *
 *
 *        扩容，容量计算结果都是2的n次幂,扩容会出现循环链表
 *        put  计算下标 1.hash hash计算有很多右移，保证保证高位也能影响下标，目的hash更散列
 *                     2.index=  h & (length-1)，能保证下标，是[0，length-1]且平均，因此容量是2的n次幂
 *                     3.hashSeed是在算hash用到的，是hash更散列，默认0，
 *        putForNullKey   key为null,直接插入数组[0]，且链表的尾部
 *        Iterator（）遍历，使用HashMap的remove会抛并发写异常，Iterator生成的时候记录expectModelCnt=modcount ，遍历会判断expectModelCount!= modCount 会抛异常（fail-fast机制），解决办法：使用Iterator的remove
 * @author hqyin
 * @date 2025/5/21 4:35 PM
 */
public class Demo1ConcurrentMap {
    public static void main(String[] args) {
        //
        test_hashMap();
        //测试HashMap fail-fast机制
        //Iterator（）遍历，使用HashMap的remove会抛并发写异常，Iterator生成的时候记录expectModelCnt=modcount ，遍历会判断expectModelCount!= modCount 会抛异常（fail-fast机制），解决办法：使用Iterator的remove
//        test_hashMap_failFast();
        //测试
//       test_concurrentHashMap_failSafe();





    }

    private static void test_hashMap() {
        HashMap<Integer,Integer> map = new HashMap<>(3);
        map.put(1,1);
        map.put(5,5);
        map.put(9,9);
    }

    private static void test_concurrentHashMap_failSafe() {
        ConcurrentHashMap<Integer,Integer> map = new ConcurrentHashMap<>(10);
        map.put(1,1);
        map.put(2,2);
        map.put(3,3);

        Iterator<Integer> it = map.keySet().iterator();
        while (it.hasNext()) {
            Integer key = it.next();
            map.remove(key);
            //解决方案，使用 it.remove
//            it.next();
//            it.remove();
        }

        System.out.println(map.size());
    }

    private static void test_hashMap_failFast() {
        HashMap<Integer,Integer> map = new HashMap<>(10);
        map.put(1,1);
        map.put(2,2);
        map.put(3,3);
        map.put(4,null);

        //modCount 这是fail-fast机制
        //抛 java.util.HashMap$HashIterator
//        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
//            map.remove(entry.getKey());
//        }

        //遍历删除使用Iterator的remove
//        Iterator<Integer> it = map.keySet().iterator();
//        while (it.hasNext()) {
////           map.remove( it.next()); //抛 java.util.HashMap$HashIterator
//            //解决方案，使用 it.remove
//            it.next();
//            it.remove();
//        }
    }
}
